// exports.NodePoolMag = void 0;
// var $logManager = require("./LogManager");
// var i = (function () {
//     function e() {
//         this.saveNode = {};
//         this.savePrefab = {};
//     }
//     Object.defineProperty(e, "instance", {
//         get: function () {
//             return this.nodepool;
//         },
//         enumerable: !1,
//         configurable: !0
//     });
//     e.prototype.createNodeCount = function (e, t, o, i) {
//         var a = this.saveNode[e];
//         if (a) {
//             $logManager.LogMgr.debug("对象池已经创建");
//         } else {
//             {
//                 a = new cc.NodePool(i);
//                 this.saveNode[e] = a;
//                 this.savePrefab[e] = o;
//                 for (var r = 0; r < t; r++) {
//                     var c = cc.instantiate(o);
//                     a.put(c);
//                 }
//             }
//         }
//     };
//     e.prototype.getNode = function (e) {
//         var t = this.saveNode[e];
//         var o = null;
//         if (t) {
//             if (t.size() > 0) {
//                 o = t.get();
//             } else {
//                 {
//                     var n = this.savePrefab[e];
//                     if (n && n.isValid) {
//                         o = cc.instantiate(n);
//                     }
//                 }
//             }
//             return o;
//         }
//         return null;
//     };
//     e.prototype.recycleNode = function (e, t) {
//         var o = this.saveNode[e];
//         if (o) {
//             if (t.isValid) {
//                 o.put(t);
//             }
//         } else {
//             $logManager.LogMgr.debug("节点池不存在", e);
//         }
//     };
//     e.prototype.clearAllNode = function () {
//         for (var e in this.saveNode) this.clearNode(e);
//     };
//     e.prototype.clearNode = function (e) {
//         var t = this.saveNode[e];
//         if (t) {
//             t.clear();
//             delete this.saveNode[e];
//             delete this.savePrefab[e];
//         }
//     };
//     e.nodepool = new e();
//     return e;
// })();
// exports.NodePoolMag = i;

// import { LogMgr } from './LogManager';

// /**
//  * 节点池管理类
//  * 建议类名：NodePoolManager
//  */
// class NodePoolMag {
//     private static nodepool: NodePoolMag = new NodePoolMag();
//     private saveNode: { [key: string]: cc.NodePool } = {};
//     private savePrefab: { [key: string]: cc.Prefab } = {};

//     private constructor() { }

//     /**
//      * 获取单例实例
//      * 建议方法名：getInstance
//      */
//     public static get instance(): NodePoolMag {
//         return this.nodepool;
//     }

//     /**
//      * 创建节点池
//      * @param poolName 节点池名称
//      * @param count 创建节点数量
//      * @param prefab 节点预制体
//      * @param component 组件类型
//      * 建议方法名：createNodePool
//      */
//     public createNodeCount(poolName: string, count: number, prefab: cc.Prefab, component?: typeof cc.Component): void {
//         let nodePool = this.saveNode[poolName];
//         if (nodePool) {
//             LogMgr.debug("对象池已经创建");
//         } else {
//             nodePool = new cc.NodePool(component);
//             this.saveNode[poolName] = nodePool;
//             this.savePrefab[poolName] = prefab;
//             for (let i = 0; i < count; i++) {
//                 const node = cc.instantiate(prefab);
//                 nodePool.put(node);
//             }
//         }
//     }

//     /**
//      * 获取节点
//      * @param poolName 节点池名称
//      * @returns 获取的节点
//      * 建议方法名：getNodeFromPool
//      */
//     public getNode(poolName: string): cc.Node | null {
//         const nodePool = this.saveNode[poolName];
//         let node: cc.Node | null = null;
//         if (nodePool) {
//             if (nodePool.size() > 0) {
//                 node = nodePool.get();
//             } else {
//                 const prefab = this.savePrefab[poolName];
//                 if (prefab && prefab.isValid) {
//                     node = cc.instantiate(prefab);
//                 }
//             }
//             return node;
//         }
//         return null;
//     }

//     /**
//      * 回收节点
//      * @param poolName 节点池名称
//      * @param node 回收的节点
//      * 建议方法名：recycleNodeToPool
//      */
//     public recycleNode(poolName: string, node: cc.Node): void {
//         const nodePool = this.saveNode[poolName];
//         if (nodePool) {
//             if (node.isValid) {
//                 nodePool.put(node);
//             }
//         } else {
//             LogMgr.debug("节点池不存在", poolName);
//         }
//     }

//     /**
//      * 清空所有节点池
//      * 建议方法名：clearAllNodePools
//      */
//     public clearAllNode(): void {
//         for (const poolName in this.saveNode) {
//             this.clearNode(poolName);
//         }
//     }

//     /**
//      * 清空指定节点池
//      * @param poolName 节点池名称
//      * 建议方法名：clearNodePool
//      */
//     public clearNode(poolName: string): void {
//         const nodePool = this.saveNode[poolName];
//         if (nodePool) {
//             nodePool.clear();
//             delete this.saveNode[poolName];
//             delete this.savePrefab[poolName];
//         }
//     }
// }

// export { NodePoolMag };

import { LogMgr } from './LogManager';

/**
 * 节点池管理类
 * 建议类名：NodePoolManager
 */
class NodePoolManager {
    // 单例对象
    private static _instance: NodePoolManager = new NodePoolManager();
    // 保存节点池
    private nodePools: { [key: string]: cc.NodePool } = {};
    // 保存节点预制体
    private prefabs: { [key: string]: cc.Prefab } = {};

    // 私有构造函数，防止外部实例化
    private constructor() {}

    /**
     * 获取单例实例
     * 建议方法名：getInstance
     */
    public static get instance(): NodePoolManager {
        return this._instance;
    }

    /**
     * 创建节点池
     * @param poolName 节点池名称
     * @param count 创建节点数量
     * @param prefab 节点预制体
     * @param component 组件类型
     * 建议方法名：createNodePool
     */
    public createNodePool(poolName: string, count: number, prefab: cc.Prefab, component?: typeof cc.Component): void {
        let nodePool = this.nodePools[poolName];
        if (nodePool) {
            LogMgr.debug("对象池已经创建");
        } else {
            nodePool = new cc.NodePool(component);
            this.nodePools[poolName] = nodePool;
            this.prefabs[poolName] = prefab;
            for (let i = 0; i < count; i++) {
                const node = cc.instantiate(prefab);
                nodePool.put(node);
            }
        }
    }

    /**
     * 获取节点
     * @param poolName 节点池名称
     * @returns 获取的节点
     * 建议方法名：getNodeFromPool
     */
    public getNodeFromPool(poolName: string): cc.Node | null {
        const nodePool = this.nodePools[poolName];
        if (nodePool && nodePool.size() > 0) {
            return nodePool.get();
        } else {
            const prefab = this.prefabs[poolName];
            if (prefab && prefab.isValid) {
                return cc.instantiate(prefab);
            }
        }
        return null;
    }

    /**
     * 回收节点
     * @param poolName 节点池名称
     * @param node 回收的节点
     * 建议方法名：recycleNodeToPool
     */
    public recycleNodeToPool(poolName: string, recycleNode: cc.Node): void {
        const nodePool = this.nodePools[poolName];
        if (nodePool && recycleNode.isValid) {
            nodePool.put(recycleNode);
        } else {
            LogMgr.debug("节点池不存在", poolName);
        }
    }

    /**
     * 清空所有节点池
     * 建议方法名：clearAllNodePools
     */
    public clearAllNodePools(): void {
        for (const poolName in this.nodePools) {
            this.clearNodePool(poolName);
        }
    }

    /**
     * 清空指定节点池
     * @param poolName 节点池名称
     * 建议方法名：clearNodePool
     */
    public clearNodePool(poolName: string): void {
        const nodePool = this.nodePools[poolName];
        if (nodePool) {
            nodePool.clear();
            delete this.nodePools[poolName];
            delete this.prefabs[poolName];
        }
    }
}

export { NodePoolManager as NodePoolMag };